/**
 * @fileoverview Ly JS Library 1.0 开发框架，轻量级的JS开发框架,此版本為適應Drewamweaver CS4的代碼提示而寫
 *  未使用繼承方式來實現,但提供了繼承的實現,用戶可以在使用時使用繼承方式
 * @author Ly
 * @version 1.0a
 */

var Ly = {
    ver : '1.0a',
    /**
     * 將參數c的所有屬性拷貝給參數obj
     * @param {Object} obj 目的對象
     * @param {Object} config 源對象
     * @param {Object} defaults (可以省略)如果存在此參數,則將c中沒有而defaults中有的屬性拷貝給obj
     * @return {Object} obj
     */
    apply : function(obj /* Object */, config /* Object */, defaults /* Object */) {
        if (defaults) {
            Ly.apply(obj, defaults);
        }
        if (obj && config && typeof config == 'object') {
            for (var p in config) {
                obj[p] = config[p];
            }
        }
        return obj;
    },
    /** @type Bolean */
    isSafari : false,
    /** @type Boolean */
    isOpera : false,
    /** @type Boolean */
    isIE : false,
    /** @type Boolean */
    isIE6 : false,
    /** @type Boolean */
    isIE7 : false,
    /** @type Boolean */
    isGecko : false,
    /** @type Boolean */
    isReady : false,
	/** @type String */
	url : location.href,
	/** @type Object */
	urlArgs : {},
    /** @type Number */
    count : 0,
    /** @type String */
    path : '',
    /** @type Array */
    cache : [],
    /** @type Array */
    EventManager : [],
    /**
     * 註冊事件
     * @param {String} evt 要註冊的事件名稱,引用Ly.Event中的常量
     * @param {Function} act 事件動作
     * @param {Object} obj (可省略)要綁定事件的對象,省略時註冊到當前對象
     */
    addEvent : function(evt /* String */, act /* Function */, obj /* Object */) {
        obj = obj || this;
		evt = evt.substr(0, 2) == 'on' ? evt.substr(2, evt.length) : evt;
		
		var fun = function(event) {
           	act.call(obj, obj, event);
        };
		
        if (obj.attachEvent) {
            evt = evt.length > 2 ? 'on' + evt : null;
            obj.attachEvent(evt, fun);
        }else if (obj.addEventListener) {
            evt = evt.length > 2 ? evt : null;
            obj.addEventListener(evt, fun, false);
        }
        
		this.EventManager.push({
            obj       : obj,
            eventName : evt,
            handler   : act,
			fun       : fun
        });
		
    },
    /**
     * 銷毀事件,省略所有參數則認為銷毀所有事件
     * @param {Object} obj 要銷毀的對象
     * @param {String} eventName 要銷毀的事件名称,省略則刪除當前對象的所有事件
	 * @param {Function} handler 要銷毀的事件
     */
    removeEvent : function(obj, eventName, handler) {
        var remove = function(a, b, c, i) {
			var em = Ly.EventManager;
			
			if (a.attachEvent) {
				b = b.substr(0, 2) == 'on' ? b : 'on' + b;
            	a.detachEvent(b, c);
			} else {
            	try {
					a.removeEventListener(b, c, false);
				} catch (e) {
				}
			}
			
			em[i].obj = em[i].handler = em[i].fun = null;
			em[i] = null;
			em.splice(i, 1);
		};
		
            var em = this.EventManager || [];
            
            for (var i = em.length - 1; i > -1; --i) {
                if (obj && typeof obj == 'object') {
                    // 銷毀obj的事件
                    if (em[i].obj === obj) {
                        if (eventName /* eventName參數有效 */) {
                            eventName = eventName.substr(0, 2) == 'on' ? eventName.substr(2) : eventName;
							
							switch (typeof handler) {
								case 'undefined':
									// 銷毀eventName事件
    	                        	em[i].eventName == eventName && remove(obj, em[i].eventName, em[i].fun, i);
									break;
								case 'function':
									em[i].handler === handler && remove(obj, eventName, em[i].fun, i);
									break;
							}
                        } else {
							remove(obj, em[i].eventName, em[i].fun, i);
                        }
                    }
                } else {
                    remove(em[i].obj, em[i].eventName, em[i].fun, i);
                }
            }
        
    },
    /** 空函數，用於創建類 */
    F : function() {},
    /**
     * 繼承,並由傳遞的值決定是否覆蓋原對象的屬性
     * 借鑒於EXT框架
     * @param {Object} subclass 子類
     * @param {Object} superclass 父類
     * @param {Object} overrides (可選參數)將它本身所攜帶的屬性對子類進行覆蓋
     * @return {Object} subclass
       <pre><code>
       // 創建空構造函數的類,直接繼承Ly.F空函數
       var base = Ly.extend(Ly.F, {
            get : function() {
            }
        });
       // 創建非空構造函數的類
       // 方法一,先創建構造函數,然後再繼承
       var base = function(p1, p2) {
            this.p1 = p1;
            this.p2 = p2;
            
            this.show = function() {
                alert(this.p1 + this.p2);
            };
       };
       Ly.extend(base, Ly.F, {
            getP1 : function() {
                return this.p1;
            },
            getP2 : function() {
                return this.p2;
            }
        });
       // 方法二,直接創建類
       var base = Ly.extend(
            function(p1, p2) {
                this.p1 = p1;
                this.p2 = p2;
                
                this.show = function() {
                    alert(this.p1 + this.p2);
                };
            }, Ly.F,
            {
                getP1 : function() {
                    return this.p1;
                },
                getP2 : function() {
                    return this.p2;
                }
            }
        );
       </code></pre>
     */
    extend : function(sb /* Object */, sp /* Object */, overrides /* Object */) {
        if (typeof sp == 'object') {
            overrides = sp;
            sp = sb;
            sb = function() {
                c.apply(this, arguments);
            };
        }
        var F = this.F, sbp, spp = sp.prototype;
        F.prototype = spp;
        sbp = sb.prototype = new F();
        if (spp.constructor == Object.prototype.constructor) {
            spp.constructor = sp;
        }
        Ly.override(sb, overrides);
        return sb;
    },
    
    /**
     * 覆蓋,用overrides覆蓋origclass中的屬性
     * @param {Object} origclass 源對象
     * @param {Object} overrides 要覆蓋的屬性列表
     * @param {Object} origclass
     */
    override : function(origclass /* Object */, overrides /* Object */) {
        if (overrides) {
            var p = origclass.prototype;
            for (var m in overrides) {
                p[m] = overrides[m];
            }
        }
        return origclass;
    },
	/**
	 * 引入外部JS文件
	 * @param {String} 要導入的外部JS路徑，支持多參數
	 */
	importJS : function(path /* String */) {
		var
			arg = arguments;
		for (var i = 0; i < arg.length; i++) {
			var
				script = Ly.createElement('script', {
					type : 'text/javascript',
					src : arg[i]
				});
			document.getElementsByTagName('head')[0].appendChild(script);
			script = null;
		}
	},
	/**
	 * 創建命名空間
	 * @param {String} 命名空間字符串，支持多參數
	 */
	namespace : function(namespace /* String */) {
		var
			arg = arguments, ns = null, nsArray, obj;
		
		for (var i = 0; i < arg.length; i++) {
			nsArray = arg[i].split('.');
			obj = nsArray[0];
			// 創建第一級對象
			eval('if (typeof ' + obj + ' == "undefined") { ' + obj + ' = {}; } ns = ' + obj + ';');
			
			for (var j = 1; j < nsArray.length; j++) {
				// 創建後續字段
				ns[nsArray[j]] = ns[nsArray[j]] || {};
				// 將新對象賦給ns，以用於下次創建新對象
				ns = ns[nsArray[j]];
			}
		}
	},
    /**
     * 獲取時鐘
     * @return {Number} 數值型唯一時鐘
     */
    getCount : function() { return ++this.count; },
    /**
     * 設置resources文件夾相對於調用頁面的路徑
     * resources文件夾中包含此框架所用到的所有CSS樣式與圖片
     * @param {String} p 要設置的路徑,此路徑為相對路徑,支持../方式
     */
    setPath : function(p /* String */) {
        this.path = p || '';
    },
    /**
     * 獲取resources文件夾相對於調用頁面的路徑
     * @return {String}
     */
    getPath : function() {
        return this.path + 'Ly' + this.ver + '/resources/';
    },
    /**
     * 按id來獲取DOM對象
     * @param {String} 多參,當為多參時返回DOM對象數組
     */
    $ : function(id/* String... */) {
        var
            elements = [],
            argc = arguments.length;
        
        for (var i = 0; i < argc; i++) {
            var element = arguments[i];
            if (typeof element == 'string') {
                element = document.getElementById(element);
            }
            if (argc == 1) { return element; }
            elements.push(element);
        }
        return elements;
    },
    /**
     * 獲取頁面中的DOM對象,並對此對象進行擴展
     */
    get : function(id /* String */) {
        var obj;
        
        if (typeof id == 'object') {
            return id;
        }
        
        // 查看緩存中是否存在此元素
        var
            c = this.cache,
            cl = c.length;
        
        for (var i = 0; i < cl; i++) {
            if (c[i].id == id && c[i].obj === document.getElementById(id)) {
                return c[i].obj;
            }
        }
        
        obj = document.getElementById(id);
        
        if (obj == null) {
            return null;
        }
        
        this.cache.push({
            id : id,
            obj : obj
        });
        return obj;
    },
	/**
	 * 按name获取
	 * @param {String} name 要获取的元素的name值
	 * @param {Number} index 若存在此参数，则返回第index个元素
	 */
	getByName : function(name /* String */, index /* Number */) {
		name = name || '';
		if (!name) return [];
		
		var els = document.getElementsByName(name) || [];
		els = [].slice.call(els, 0);
		
		if (arguments.length > 1) {
			index = index || 0;
			return els[index] || null;
		}
		return els;
	},
	/**
	 * 按tagName获取
	 * @param {String} name 要获取的元素的tagName值
	 * @param {Number} index 若存在此参数，则返回第index个元素
	 */
	getByTagName : function(name /* String */, index /* Number */) {
		name = name || '';
		if (!name) return [];
		
		var els = document.getElementsByTagName(name) || [];
		els = [].slice.call(els, 0);
		
		if (arguments.length > 1) {
			index = index || 0;
			return els[index] || null;
		}
		return els;
	},
    /**
     * 補齊字符串,用於數字字符串補齊
     * @param {String} value 源字符串
     * @param {Number} d 要取的位數,默認是2
     * @param {String} fill 填充不足的位數,默認用0來填充
     * @return 處理後的字符串
     */
    fill : function(value /* String */, d /* Number */, fill /* String */) {
        var tmp = '';
        
        if (value == undefined) {
            return value;
        }
        if (d == undefined) { d = 2; }
        if (fill == undefined) { fill = '0'; }
        
        if (value.toString().length < d) {
            for (var i = 0; i < d; i++) {
                tmp += fill.toString();
            }
            
            return (tmp + value).slice(-d);
        } else {
            return value;
        }
    },
    
    /**
     * 復制字符串
     * @param {String} str 要復制的字符串
     * @param {String} num 要復制的次數
     * @return {Number} 復制後的字符串
     */
    copy : function(str, num) {
        var
            tmp = '';
        for (var i = 0; i < num; i++) {
            tmp += str;
        }
        return tmp;
    },
    
    /**
     * 格式化時間串,支持Date對象
     * @param {Number} time 要格式化的時間串,或者是一个Date对象
     * @param {String} format 格式,如:yyyymmddhhiiss yyyy-mm-dd hh:ii:ss
     * @return {String} 格式化后的时间串
     */
    formatTime : function(time /* Number */, format /* String */) {
		var
            y = format.findCount('y'),
            m = format.findCount('m'),
            d = format.findCount('d'),
            h = format.findCount('h'),
            i = format.findCount('i'),
            s = format.findCount('s');
        
        time = time || '';
        format = format || '';
        format = format.toLowerCase();
		
		if (time == '') { return time; }
		if (time.constructor == Date) {
			var tmp = '' + time.getFullYear() +
					  ('00' + (time.getMonth() + 1)).slice(-2) +
					  ('00' + time.getDate()).slice(-2) +
					  ('00' + time.getHours()).slice(-2) +
					  ('00' + time.getMinutes()).slice(-2) +
					  ('00' + time.getSeconds()).slice(-2);
			time = tmp;
		}
        
		/*
        if (time.length < format.length) {
            alert('要格式化的时间串与转换格式不一致!');
            return false;
        }
		*/
        
        if (y > 0) {
            format = format.replace(Ly.copy('y', y), time.substr(0, 4).slice(-y));
        }
        if (m > 0) {
            format = format.replace(Ly.copy('m', m), ('00' + time.substr(4, 2)).slice(-m));
        }
        if (d > 0) {
            format = format.replace(Ly.copy('d', d), ('00' + time.substr(6, 2)).slice(-d));
        }
        if (h > 0) {
            format = format.replace(Ly.copy('h', h), ('00' + time.substr(8, 2)).slice(-h));
        }
        if (i > 0) {
            format = format.replace(Ly.copy('i', i), ('00' + time.substr(10, 2)).slice(-i));
        }
        if (s > 0) {
            format = format.replace(Ly.copy('s', s), ('00' + time.substr(12, 2)).slice(-s));
        }
        return format;
    },
	
	/**
	 * 對時間進行运算
	 * @param {Number} time 要進行運行的時間串,可以為Date對象,或14位字符串
	 * @param {Object} config 要進行加減運行的字段
	 * config = { year : 2, month : 3, date : 2, hour : 2, minute : 2, second : 2 }
	 * @param {String} format 返回格式,如yyyy-mm-dd hh:ii:ss,省略則返回Date對象
	 * @return {String} 加減操作後的時間串
	 */
	addingTime : function(time /* Number */, config /* Object */, format /* String */) {
		var
			date;
		
		if (time.constructor == Date) {
			date = time;
		} else {
			if (time.length != 14) {
				alert('将时间补足为14位时间串!');
				return false;
			}
			date = new Date(time.substr(0, 4),
							time.substr(4, 2) - 1,
							time.substr(6, 2),
							time.substr(8, 2),
							time.substr(10, 2),
							time.substr(12, 2));
		}
		for (var p in config) {
			switch (p.toLowerCase()) {
				case 'year':
					date.setFullYear(date.getFullYear() + config[p]);
					break;
				case 'month':
					date.setMonth(date.getMonth() + config[p]);
					break;
				case 'date':
					date.setDate(date.getDate() + config[p]);
					break;
				case 'hour':
					date.setHours(date.getHours() + config[p]);
					break;
				case 'minute':
					date.setMinutes(date.getMinutes() + config[p]);
					break;
				case 'second':
					date.setSeconds(date.getSeconds() + config[p]);
					break;
			}
		}
		
		return format ? this.formatTime(date, format) : date;
	},
	
	/**
	 * 給字符串添加軟換行
	 * @param {String} str 要添加軟換行的字符串
	 * @return {String} 添加軟換行後的字符串
	 */
	addWBR : function(str /* String */) {
		return ('>' + str).replace(/(>)\s*([^<>]+)(?=[<]?)/g, function(a, b, c) { return b + (!/*@cc_on !@*/0 ? c.split('').join('<wbr />') : c) }).substr(1);
	},
    
    /**
    * 判斷是否為閏年
    * @param {Number} year 要判斷的年份
    * @return true/false
    */
    isLeapYear : function(year /* Number */) {
        year = parseInt(year);
        var
            chk4 = (0 == year % 4),
            chk100 = (0 == year % 100),
            chk400 = (0 == year % 400);
        
        if ((chk4 && !chk100) || chk400) { return true; } else { return false; }
    },
    
    /**
     * @des 校驗IP地址是否合法,並檢查IP地址類型.
     * @param {String} ipStr 要校驗的IP地址
     */
    ip : function(ipStr /* String */) {
        // 參數格式校驗,成功繼續,失敗返回-1
		ipStr = ipStr || '';
        ipStr = ipStr.replace(/\s/g, '');
        
        var reg = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
        
        if (reg.test(ipStr) == false) { return -1; }
        
        // IP地址合法性校驗 成功繼續,失敗返回-2
        var arr = ipStr.split(".");
        
        for (var i=0; i < 4; i++) {
            arr[i] = parseInt(arr[i],10);
            if (parseInt(arr[i],10) > 255) { return -2; }
        }
        
        var ip = arr.join(".");
        
        /**
         * @des 返回IP地址的類型,包括:
         * 異常:0 A類:1 B類:2 C類:3 D類:4 E類:5 A類私有:6 B類私有:7 C類私有:8 本機IP:9 廣播地址:10
         * A類子網掩碼:11 B類子網掩碼:12 C類子網掩碼:13
         */
        
        var retVal = 0;
        var n = arr[0];
        
        if (ip == "255.255.255.255") { retVal = 10; }
        else if (ip == "255.255.255.0") { retVal = 13; }
        else if (ip == "255.255.0.0") { retVal = 12; }
        else if (ip == "255.0.0.0") { retVal = 11; }
        else if (ip == "0.0.0.0" || ip == "127.0.0.1") { retVal = 9; }
        else if (n <= 126) { retVal = (n == 10 ? 6 : 1); }
        else if (n <= 191) { retVal = (n == 172 ? 7 : 2); }
        else if (n <= 223) { retVal = (n == 192 ? 8 : 3); }
        else if (n <= 239) { retVal = 4; }
        else if (n <= 255) { retVal = 5; }
        
        return retVal;
    },
    
    /**
     * 補齊IP地址
     * @param {String} ip 要補齊三位的IP地址
     * @return {String} 補課後的IP地址
     */
    ip3 : function(ip /* String */) {
        if (Ly.ip(ip) < 1) {
            return ip;
        }
        return function() {
                var arr = ip.split('.');
                return Ly.fill(arr[0], 3) + '.' +
                       Ly.fill(arr[1], 3) + '.' +
                       Ly.fill(arr[2], 3) + '.' +
                       Ly.fill(arr[3], 3);
        }();
    },
    
    /**
     * 驗證MAC地址的合法性
     * @param {String} m 要驗證的MAC地址
     */
    mac : function(m /* String */) {
        if(/^([0-9A-Fa-f]{2})(-[0-9A-Fa-f]{2}){5}|([0-9A-Fa-f]{2})(:[0-9A-Fa-f]{2}){5}/.test(m)) {
            return true;
        }
        return false;
    },
	
	/**
	 * 判断手机号
	 * @param {Number} m 手机号
	 */
	mobile : function(m /* Number */) {
		m = m || 0;
		if (!m) { return false; }
		return /^(((13[0-9]{1})|159|(15[0-9]{1}))+\d{8})$/.test(m);
	},
    
    /**
     * 驗證是否为整数
     * @param {String} str 要驗證的字符串
     */
    isInt : function(str /* String */) {
        if(/^[1-9]+[0-9]*]*$/.test(str)) {
            return true;
        }
        return false;
    },
    
    /**
     * 驗證是否为空或全部为空格
     * @param {String} str 要驗證的字符串
     */
    isEmpty : function(str /* String */) {
        str = str || ''; 
        if(str.toString().trim() == '') {
            return true;
        }
        return false;
    },
    
    /**
     * 是否包含特殊字符
     * @param {String} str 要測試的字符串
     */
    hasSpecialChars : function(str /* String */) {
        if(/<|>|'|;|&|#|"|\$|\*|\.|\[|\]|\{|\}|\%|\`|\||\:|\,|\\|\//.test(str)) {
            return true;
        }
        return false;
    },
	
	/**
	 * 對字符串進行編碼
	 * @param {String} str 要編碼的字符串
	 * @return {String} 編碼後的字符串
	 */
	encodeSpecialChars : function(str /* String */) {
		return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/'/g, '&acute;').replace(/"/g, '&quot;');
	},
    
	/**
	 * 對字符串進行解碼
	 * @param {String} str 要解碼的字符串
	 * @return {String} 解碼後的字符串
	 */
	decodeSpecialChars : function(str /* String */) {
		return str.replace(/&quot;/g, '"').replace(/&acute;/g, '\'').replace(/&gt;/g, '>').replace(/&lt;/g, '<').replace(/&amp;/g, '&');
	},
	
    /**
     * 啟用/停用按鈕
     * @param {Object} element 應用此事件的對象
     * @param {Boolean} state 狀態，啟用/停用
     * @param {String} v 要顯示的文字
     */
    disabled : function(element /* Object */, state /* Boolean */, v /* String */) {
        element = element.length == undefined ? [element] : element;
        for (var i = 0; i < element.length; i++) {
            try {
                with (element[i]) {
                    disabled = state;
                    style.cursor = state ? 'default' : 'pointer';
                    value = v || value;
                }
            } catch (e) {}
        }
    },
    
    /**
     * 創建標籤
     * @param {String} target 標籤名稱,為空則創建一個空的DIV對象
     * @param {Object} config 屬性列表
     * @return {Object} 所創建的對象
     */
    createElement : function(target /* String */, config /* Object */) {
        target = target || 'div';
        config = config || {};
        
        var tag = document.createElement(target);
        for (var p in config) {
            if (p.toLowerCase() == 'style') {
                tag.style.cssText = config[p];
            } else if (p.toLowerCase() == 'class' || p.toLowerCase() == 'cls') {
                tag.className = config[p];
			} else if (p.toLowerCase() == 'innerhtml') {
				tag.innerHTML = config[p];
//            } else if (p.toLowerCase() == 'innerhtml') {
//                alert('请先将当前对象添加到文档流中再添加innerHTML!');
            } else {
                tag.setAttribute(p, config[p]);
            }
        }
		try {
	        return tag;
		} finally {
			tag = null;
		}
    },
	
	/**
	 * 獲取URL參數
	 * @param {String} id 參數名稱
	 * @return {String} id對應的值
	 */
	getArgs : function(id) {
		return Ly.urlArgs[id] || '';
	},
    
    /**
     * 檢測值的有效性
     * @param {String} value 要檢測的值
     * @param {String} fill 如果值為undefined型,則返回源值
     * @return {String} 有效則返回源值，否則返回參數fill
     */
    getValue : function(value, fill) {
        if (typeof(value) == 'undefined') {
            return (typeof(fill) == undefined ? '' : fill);
        }
        return value;
    },
    
    /**
     * 將序列化的JSON數據轉成對象
     * @param {String} json 要轉換成JSON格式的數據
     */
    getJSON : function(json) {
        eval('var tmp = ' + json);
        return tmp;
    },
	
	/**
	 * 对数组进行序列化
	 * @param {Array} data 需要进行序列化的对象
	 */
	encodeArray : function(data /* Array */) {
		var str = '[';
		for (var i = 0, len = data.length; i < len; ++i) {
			switch (typeof data[i]) {
				case 'boolean':
					str += data[i] + ',';
					break;
				case 'number':
					str += data[i] + ',';
					break;
				case 'string':
					str += '"' + Ly.encodeSpecialChars(data[i]) + '",';
					break;
				case 'object':
					if (data[i] && data[i].constructor === Array) {
						str += arguments.callee(data[i]) + ',';
					} else {
						str += Ly.encodeJSON(data[i]) + ',';
					}
					break;
			}
		}
		return str.substr(0, str.length - 1) + ']';
	},
	/**
	 * 对JSON数据进行序列化
	 * @param {Object} data 需要进行序列化的对象
	 */
	encodeJSON : function(data /* Object */) {
		var str = '{',
			arg = arguments,
			array = function(d) {
			};
		
		for (var p in data) {
			switch (typeof data[p]) {
				case 'boolean':
					str += '"' + p + '":' + data[p] + ',';
					break;
				case 'number':
					str += '"' + p + '":' + data[p] + ',';
					break;
				case 'string':
					str += '"' + p + '":"' + Ly.encodeSpecialChars(data[p]) + '",';
					break;
				case 'object':
					if (data[p] && data[p].constructor === Array) {
						str += '"' + p + '":' + array(data[p]) + ',';
					} else {
						console && console.log(p);
					}
			}
		}
		return str.substr(0, str.length - 1) + '}';
	},
	
	/**
	 * 对JSON数据进行反序列
	 * @param {String} json 序列化后的JSON数据
	 * @return {Object} JSON对象
	 */
	decodeJSON : function(json /* String */) {
		return eval('(' + json + ')');
	},
	
	/**
	 * 将JSON数据转换成数组
	 * @param {Object} json 要转换的JSON数据
	 * @param {Boolean} flag 是否反转name与value，默认false
	 * @return {Array} 返回格式为name,value值对的数据。[{ name : value }]
	 */
	jsonToArray : function(json /* Object */, flag /* Boolean */) {
		var data = [], name, value;
		json = json || {};
		
		for (var p in json) {
			if (flag) {
				name = typeof json[p] == 'object' ? arguments.callee(json[p]) : json[p];
				value = p;
			} else {
				name = p;
				value = typeof json[p] == 'object' ? arguments.callee(json[p]) : json[p];
			}
			
			data.push({
				name  : name,
				value : value
			});
		}
		
		return data;
	},
    
    /**
     * 獲取元素相對於原點的橫坐標值
     * @param {Object} element 要獲取的元素
     * @return {Number} 相對於原點的橫坐標值
     */
    getX : function(element, target) {
        if (typeof element != 'object') {
            alert('getX参数类型不正确，期望一个DOM元素对象！');
            return false;
        }
        var x = element.offsetLeft;
        var p = element.offsetParent || element.target;
        if (p != null && p !== target) x += this.getX(p, target);
        return x;
    },
    
    /**
     * 獲取元素相對於原點的縱坐標值
     * @param {Object} element 要獲取的元素
     * @return {Number} 相對於原點的縱坐標值
     */
    getY : function(element, target) {
        if (typeof element != 'object') {
            alert('getY参数类型不正确，期望一个DOM元素对象！');
            return false;
        }
        var y = element.offsetTop;
        var p = element.offsetParent || element.target;
        if (p != null && p !== target) y += this.getY(p, target);
        return y;
    },
    
    /**
     * 生成隨機數
     * @param {Number} min 最小值,默認為0
     * @param {Number} max 最大值,默認為1
     * @param {Number} len 生成的隨機數位數,默認為1
     * @return {Number} 生成的隨機數
     */
    getRandom : function(min, max, len) {
        var
            tmp,
            data = [];
        
        min = min || 0;
        max = max || 1;
        len = len || 1;
        
        if (min > max) {
            tmp = min;
            max = tmp;
            min = max;
        }
        for (var i = 0; i < len; i++) {
            data.push(Math.floor(Math.random() * (max - min + 1) + min));
        }
        return data.join('');
    },

    /**
     * 设置页面中容器的高度
     * @param {Object} obj 要设置高度的对象
     * @param {Object} des 参照对象，默认body
     * @param {Number} h 需要减掉的高度
     */
    setHeight : function(obj1, obj2, h) {
        var height = obj2.clientHeight;
        h = h || 0;
        
        if (obj2 === document.body || obj2 === document.documentElement) {
            height += window.scrollMaxY || obj2.scrollTop;
        }
        
        obj1.style.height = (height - h) + 'px';
        
        Ly.addEvent('onresize', function() {
//			var that = arguments.callee,
//				t = new Date();
//			
//			if (typeof that.time == 'undefined') {
//				that.time = t.getTime();
//			} else {
//				if (t.getTime() - that.time < 100) {
//					that.time = t.getTime();
//					return ;
//				}
//				that.time = t.getTime();
//			}
            obj1.style.height = '0px';
            var height = obj2.clientHeight;
            h = h || 0;
            
            if (obj2 === document.body || obj2 === document.documentElement) {
               // height += window.scrollMaxY || obj2.scrollTop;
            }
            
            obj1.style.height = (height - h) + 'px';
        }, window);
    },
    /**
     * 设置页面中容器的宽度
     * @param {Object} obj 要设置宽度的对象
     * @param {Object} des 参照对象，默认body
     * @param {Number} w 需要减掉的宽度
     */
    setWidth : function(obj1, obj2, w) {
        var width = obj2.clientWidth;
        w = w || 0;
        
        if (obj2 === document.body || obj2 === document.documentElement) {
            width += window.scrollMaxX || obj2.scrollLeft;
        }
        obj1.style.width = (width - w) + 'px';
        
        Ly.addEvent('onresize', function() {
//			var that = arguments.callee,
//				t = new Date();
//			
//			if (typeof that.time == 'undefined') {
//				that.time = t.getTime();
//			} else {
//				if (t.getTime() - that.time < 100) {
//					that.time = t.getTime();
//					return ;
//				}
//				that.time = t.getTime();
//			}
            obj1.style.width = '0px';
            var width = obj2.clientWidth;
            w = w || 0;
            
            if (obj2 === document.body || obj2 === document.documentElement) {
                //width += window.scrollMaxX || obj2.scrollLeft;
            }
            obj1.style.width = (width - w) + 'px';
        }, window);
    },
	/**
	 * 將指定元素的值去空格．
	 * @param {Object} 要進行去空格處理的元素，可是是任意多個參數
	 */
	trim : function() {
		var
			_args = arguments;
		
		for (var i = 0; i < _args.length; ++i) {
			if (_args[i] != null && typeof _args[i].value != 'undefined') {
				_args[i].value = _args[i].value.trim();
			}
		}
	},
	/**
	 * 從左邊替換掉指定的字符串
	 * @param {String} str 源串
	 * @param {String} s 被替換的字符串
	 * @param {String} d 替換的字符串
	 * @return {String} 替換后的字符串
	 */
	replaceLeft : function(str /* String */, s /* String */, d /* String */) {
		if (str[0] == s) {
			return '' + d + Ly.replaceLeft(str.substr(s.length), s, d);
		}
		return str;
	},
	/**
	 * 從右邊替換掉指定的字符串
	 * @param {String} str 源串
	 * @param {String} s 被替換的字符串
	 * @param {String} d 替換的字符串
	 * @return {String} 替換后的字符串
	 */
	replaceRight : function(str /* String */, s /* String */, d /* String */) {
		if (str[str.length - 1] == s) {
			return '' + Ly.replaceRight(str.substr(0, str.length - 1), s, d) + d;
		}
		return str;
	},
	/**
	 * 判斷元素間的包含關係。用於非IE下。IE下有contains方法
	 * @param {Object} parent 被測試對象obj的父對象，即是否為obj的祖先
	 * @param {Object} obj 要測試的對象
	 * @return [Boolean} 若包含則返回true，反之false
	 */
	owner : function(parent /* Object */, obj /* Object */) {
		if (!obj) {
			return false;
		} else if (obj.parentNode === parent || obj === parent) {
			return true;
		} else if (obj.parentNode === document.body) {
			return false;
		} else {
			return arguments.callee(parent, obj.parentNode);
		}
	},
	/**
	 * 将数字转成带逗号的
	 * @param {Number} num
	 * @return {String} 加逗号后的数字串
	 */
	num2str : function(num /* Number */) {
		num = num || 0;
		var arr = num.toString().split('.');
		var arr1 = arr[0].toString().split('');
		var index = 0;
		var str = '';
		
		for (var i = arr1.length - 1; i >=0; --i) {
			if (index != 0 && index % 3 == 0) {
				str = arr1[i] + ',' + str;
			} else {
				str = arr1[i].toString() + str;
			}
			index++;
		}
		if (arr.length > 1) {
			str += '.' + arr[1];
		}
		return str;
	},
	/**
	 * 克隆數據，針對陣列，對象
	 * @param {Object} obj 要克隆的對象
	 * @return {Object} 克隆后的數據
	 */
	clone : function(obj /* Object */) {
		var data;
		switch (typeof obj) {
			case 'object':
				if (obj.constructor === Array) {
					data = [];
					for (var i = 0, len = obj.length; i < len; ++i) {
						data.push(arguments.callee(obj[i]));
					}
					return data;
				}
				data = {};
				for (var p in obj) {
					data[p] = arguments.callee(obj[p]);
				}
				return data;
				break;
			default :
				return obj;
		}
	},
	/**
	 * 验证器，对输入框进行验证
	 * @param {RegExp} reg 用于验证的正则表达式
	 * @param {Object} el 要进行验证的input,textarea元素，支持多个。
	 */
	inputValidation : function(reg, el /* , el2, ... */) {
		var v = function() {
			if (reg.test(this.value)) {
				this.setAttribute('inputdata', this.value);
			} else {
				this.value = this.getAttribute('inputdata');
			}
		};
		if (!el) { return ; }
		[].slice.call(arguments, 1).each(function(el) {
			Ly.addEvent('oninput', v, el);
			Ly.addEvent('onpropertychange', v, el);
		});
	},
    /**
     * 頁面DOM元素加載完成後觸發,在onload事件之前
     */
    onReady : function() {
        var args = arguments;
		var funs = function() {
			for (var i = 0, len = args.length; i < len; ++i) {
				if (typeof args[i] == 'function') {
					args[i]();
				}
			}
		};
		if (!Ly.isIE) {
            Ly.addEvent('DOMContentLoaded', funs, document);
        } else {
            var lyTimer = new Ly.Timer();
            
            lyTimer.start(function() {
                try {
                    document.body.doScroll('left');
                    lyTimer.stop();
                    funs();
                } catch (e) {}
            }, 100);
        }
    },
    /**
     * 回車事件
     * @param {Array} config 要綁定事件的數組，格式如下：
     config = [{
        obj : // 要綁定的對象,
        fn : // 要執行的事件，此函數將接受obj參數
     */
    enter : function(config) {
        document.onkeydown = function(event) {
            var e=event || window.event;
            var keyCode = e.keyCode ? e.keyCode : e.which ? e.which : e.charCode;
            
            if (keyCode == 0x0D){
                var srcElement = e.srcElement || e.target;
                
                if (config.constructor == Array) {
                    for (var i = 0; i < config.length; i++) {
                        if (srcElement == config[i].obj){
                            config[i].fn(config[i].obj);
                        }
                    }
                }
            }   
        };
    }
};

/**
 * 常量列表
 */
Ly.Event = {
    OK : 'ok',
    CANCEL : 'cancel',
    OKCANCEL : 'okcancel',
    YESNOCANCEL : 'yesnocancel',
    
    ONBLUR : 'onblur',
    ONFOCUS : 'onfocus',
    ONCLICK : 'onclick',
    ONDBLCLICK : 'ondblclick',
    ONKEYDOWN : 'onkeydown',
    ONKEYPRESS : 'onkeypress',
    ONKEYUP : 'onkeyup',
    ONMOUSEDOWN : 'onmousedown',
    ONMOUSEUP : 'onmouseup',
    ONMOUSEOVER : 'onmouseover',
	ONMOUSEOUT : 'onmouseout',
    ONCHANGE : 'onchange',
    ONSELECT : 'onselect'
};

/**
 * 用于生成大数据量,当用for循环来生成大数据量时不会动态的生成,因为当for循环执行时CPU一直被占用,页面不会更新.
 * <pre><code>
    var
        arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
        index = 0,
        MAX = arr.length,
        builder = new Ly.Builder();
    
    builder.start(function() {
        var
            row,
            cell;
        
        if (index >= MAX) {
            builder.end();
            return true;  // 一定要加返回,否则会多执行一次
        }
        
        row = main.insertRow();
        cell = row.insertCell();
        cell.innerHTML = arr[index];
        cell = row.insertCell();
        cell.innerHTML = arr[index] + '...';
        index++;
    });
 </code></pre>
 */
Ly.Builder = function() {
    var
        timer,
        interval = 10;
    
    this.start = function(fn) {
        timer = setInterval(fn, interval);
    };
    this.end = function() {
        clearInterval(timer);
        delete this.start;
        delete this.end;
    }
};

/**
 * 計時器,用於在某段時間內循環執行某些操作
 */
Ly.Timer = function() {
    var _this = this;
    
    this.config = {
        fn : function() {},                    // 要執行的函數
        runningCount : 0,                      // 觸發後的總次數
        running : false,                       // 計時器是否正在執行
        count : 0,                             // 總的執行次數
        timer : null,                          // 計時器指針
        delay : 1000,                          // 計時器延遲,默認1秒
        execute : function() {
            var c = _this.config;
            c.runningCount++;                  // 執行次數自加一
            c.running = true;                  // 運行狀態為true
            
            if (c.count != 0 && c.runningCount > c.count) {
                clearInterval(c.timer);        // 釋放計時器指針
                c.running = false;             // 運行狀態為false
                c.runningCount = c.count;      // 執行次數等於設置的次數
                return true;
            }
            c.fn();                            // 執行用戶自定義事件
        }
    };
};
Ly.Timer.prototype = {
    /**
     * 設置執行次數
     * @param {Number} count 計時器總的執行次數
     */
    repeatCount : function(count /* Number */) {
        if (typeof count != 'number') {
            alert('repeatCount期望一个数值型参数!');
            return false;
        }
        this.config.count = count;
    },
    
    /**
     * 開始計時器
     * @param {Function} fn 要執行的函數
     * @param {Number} rc 延遲多久執行,單位毫秒
     * @param {Number} count (可選)總執行次數,0代表無限次
     */
    start : function(fn /* Function */, rc /* Number */, count /* Number */) {
        var c = this.config;
        
        c.delay = rc || 1000;
        c.count = count || 0;
        c.fn = fn;
        
        c.timer = setInterval(c.execute, c.delay);
		fn = null;
    },
    
    // 停止計時器
    stop : function() {
        var c = this.config;
        
        c.running = false;
        clearInterval(c.timer);
    },
    
    // 如果計時器正在運行,則停止計時器,並將currentCount屬性設回為0,這類似於秒錶的重置按鈕
    reset : function() {
        var c = this.config;
        c.runningCount = 0;
        c.timer = setInterval(c.execute, c.delay);
    },
    
    // 計時器從0開始後觸發觸發的總次數
    currentCount : function() {
        return this.config.runningCount;
    },
    
    /**
     * 計時器事件間的延遲(以毫秒為單位)
     * @param {Number} count 執行的延遲數
     */
    delay : function(count /* Number */) {
        if (typeof count == 'undefined') {
            alert('delay期望一個數值型參數!');
            return false;
        }
        this.config.delay = count;
    },
    
    // 計時器的當前狀態,如果計時器正在運行,則為true,否則為false
    running : function() {
        return this.config.running;
    }
};

/**
 * AJAX方式發送數據
 */
Ly.Ajax = (function() {
	var xmlHttp = createXMLHttpRequest(),
		control = {
			list : [],
			lock : false
		},
		_this = this;
	
	function method(m /* String */) {
		m = m || '';
		control.list[control.list.length - 1].method = m.toUpperCase() == 'GET' ? 'GET' : 'POST';
		return _this;
	}
	
	function charset(c /* String */) {
		var _charset;
		c = (c || '').toUpperCase();
		switch (c) {
			case 'GB2312':
				_charset = 'GB2312';
				break;
			case 'GBK':
				_charset = 'GBK';
				break;
			case 'GB18030':
				_charset = 'GB18030';
				break;
			case 'BIG5':
				_charset = 'BIG5';
				break;
			default :
				_charset = 'UTF-8';
		}
		control.list[control.list.length - 1].charset = _charset;
		return _this;
	}
	
	function url(u /* String */) {
		control.list[control.list.length - 1].url = u || document.URL;
		return _this;
	}
	
	function async(a /* String */) {
			control.list[control.list.length - 1].async = typeof a == 'boolean' ? a : true;
			return _this;
	}
	
	function success(fn /* Function */) {
		if (typeof fn == 'function' && fn.constructor == Function) {
			control.list[control.list.length - 1].success = fn;
		} else {
			control.list[control.list.length - 1].success = function() {};
		}
		return _this;
	}
	
	function failure(fn /* Function */) {
		if (typeof fn == 'object' && fn.constructor == Function) {
			control.list[control.list.length - 1].failure = fn;
		} else {
			control.list[control.list.length - 1].failure = function() {};
		}
		return _this;
	}
	
	function params(p /* Object */) {
		var _params = '';
		p = p || {};
		if (typeof p == 'string') {
			_params = p;
		} else if (typeof p == 'object') {
			for (var _p in p) {
				if (typeof _p == 'undefined' || typeof p[_p] == 'undefined') {
					alert('参数' + _p + '未定义！');
				}
				_params += '&' + _p + '=' + p[_p].toString().replace(/\+/g, '%2B').replace(/\&/g, '%26');
			}
			if (_params.length > 1) {
				_params = _params.substr(1);
			}
		}
		control.list[control.list.length - 1].params = _params;
		return _this;
	}
	
	function createXMLHttpRequest() {
		var xh;
		
		try {
			 xh = new XMLHttpRequest();
		} catch(e) {
			try {
				xh = new ActiveXObject('Microsoft.XMLHTTP');
			} catch(e) {
				try {
					xh = new ActiveXObject('MSXML2.XMLHTTP');
				} catch(e) {
					alert('創建XMLHttp對象失敗!');
					xh = null;
				}
			}
		}
		
		Ly.addEvent('onunload', function() {
			Ly.Ajax.destroy();
		}, window);
		
		return xh;
	}
	
	function send() {
		if (xmlHttp && !control.lock && control.list.length > 0) {
			var obj = control.list.shift();
			
			control.lock = true;
			xmlHttp.abort();
			xmlHttp.open(obj.method, obj.url, obj.async);
			xmlHttp.onreadystatechange = function() {
				if (xmlHttp.readyState == 4) {
					if (xmlHttp.status == 200) {
						obj.success.constructor == Function && obj.success(xmlHttp.responseText || '');
					} else {
						obj.failure.constructor == Function && obj.failure && obj.failure(xmlHttp.responseText || '');
					}
					control.lock = false;
					
					setTimeout(Ly.Ajax.send, 0);
				}
			};
			xmlHttp.setRequestHeader('If-Modified-Since', '0');
			if (obj.method == 'POST') {
				xmlHttp.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded;charset=' + obj.charset);
			}
			
			xmlHttp.send(obj.params);
		}
		return _this;
	}
	
	return {
		control : function() {
			return control;
		},
		xmlHttp : function() {
			return xmlHttp;
		},
		destroy : function() {
			xmlHttp && xmlHttp.abort()
			xmlHttp && xmlHttp.onreadystatechange && (xmlHttp.onreadystatechange = null);
			xmlHttp = null;
		},
		request : function(config /* Object */) {
			control.list.push({});
			config = config || {};
			method(config.method);
			charset(config.charset);
			url(config.url);
			async(config.async);
			success(config.success);
			failure(config.failure);
			params(config.params);
			!control.lock && send();
			return this;
		},
		send : function() {
			!control.lock && send();
		}
	};
})();
(function() {
    var ua = navigator.userAgent.toLowerCase();

    var isStrict = document.compatMode == "CSS1Compat",
        isOpera = ua.indexOf("opera") > -1,
        isSafari = (/webkit|khtml/).test(ua),
        isIE = !isOpera && ua.indexOf("msie") > -1,
        isIE7 = !isOpera && ua.indexOf("msie 7") > -1,
        isGecko = !isSafari && ua.indexOf("gecko") > -1,
        isBorderBox = isIE && !isStrict,
        isWindows = (ua.indexOf("windows") != -1 || ua.indexOf("win32") != -1),
        isMac = (ua.indexOf("macintosh") != -1 || ua.indexOf("mac os x") != -1),
        isLinux = (ua.indexOf("linux") != -1),
        isSecure = window.location.href.toLowerCase().indexOf("https") === 0;
    
    Ly.isOpera = isOpera;
    Ly.isIE = isIE;
    Ly.isIE6 = isIE && !isIE7;
    Ly.isIE7 = isIE7;
    Ly.isGecko = isGecko;
    Ly.onReady(function() {
        Ly.isReady = true;
		Ly.addEvent('onunload', function() {
			Ly.removeEvent();
			Ly.Ajax.destroy();
		}, window);
	});
	
	// 提取URL中的參數
	var u = location.search.substr(1),
		arr1,
		arr2;
	
	if (u != '') {
		arr1 = u.split('&');
		for (var i = 0; i < arr1.length; ++i) {
			if (arr1[i].indexOf('=') == -1) { continue; }
			
			arr2 = arr1[i].split('=');
			if (arr2[0] == '') { continue; }
			// 解碼，針對東南亞語種
			Ly.urlArgs[arr2[0]] = decodeURIComponent(arr2[1]);
		}
	}
})();

// 扩展String对象，使其拥有VBS的Trim()方法
String.prototype.trim = function() {
    return this.replace(/(^\s*)|(\s*$)/g, '');
}

// 扩展String对象，使其拥有VBS的LTrim()方法
String.prototype.ltrim = function() {
    return this.replace(/(^\s*)/g, '');
}

// 扩展String对象，使其拥有VBS的RTrim()方法
String.prototype.rtrim = function() {
    return this.replace(/(\s*$)/g, '');
}

/**
 * 扩展String对象,添加查找字符串出现的次数
 * @param {String} str 要测试的字符串
 */
String.prototype.findCount = function(str) {
    return this.split(str).length - 1;
}

/**
 * 擴展Array對象，添加each方法
 * @param {Function} fn 每個陣列元素將要執行的方法
 * @return {Array} 陣列對象
 */
Array.prototype.each = function(fn) {
	for (var i = 0, len = this.length; i < len; ++i) {
		fn.call(this, this[i], i);
	}
	return this;
}

if (!Array.prototype.indexOf) {
	Array.prototype.indexOf = function(elt /*, from*/) {
		var len = this.length;

		var from = Number(arguments[1]) || 0;
		
		from = (from < 0) ? Math.ceil(from) : Math.floor(from);
		
		if (from < 0) {
			from += len;
		}

		for (; from < len; from++) {
			if (from in this && this[from] === elt) {
				return from;
			}
		}
		return -1;
	};
}

/**
 * 对Select进行扩展
 */
var Select = function(id) {
	var _this = this;
	
	this.config = {
		id   : id,
		data : [],
		obj  : typeof id == 'object' ? id : Ly.get(id)
	};
	
	this.method = {
		// 追加数据
		append : function() {
			var obj = _this.config.obj,
				data = _this.config.data;
			
			for (var i = 0, len = data.length; i < len; ++i) {
				obj.options[obj.length] = new Option(data[i].name, data[i].value);
			}
			
			return this;
		},
		/**
		 * 删除数据，若无参数，则清空所有数据
		 * @param {String} value 要删除的数据
		 * @param {Boolean} flag 匹配方式，默认false，即按value值
		 */
		clear : function(value, flag) {
			var obj  = _this.config.obj,
				flag = arguments.length;
			
			for (var i = obj.length - 1; i > -1; --i) {
				var tmp = flag ? obj.options[i].text : obj.options[i].value;
				if (tmp == value || !flag) {
					obj.remove(i);
				}
			}
			return this;
		}
	};
};

Select.prototype = {
	version : '1.0',
	/**
	 * 绑定数据
	 * @param {Array} data 要绑定的数据。格式：[{ name : '显示的名称', value : '值' }]
	 */
	bind : function(data /* Array */) {
		data = data || [];
		
		if (data.constructor !== Array) {
			alert('无法初始化数据！');
			return this;
		}
		
		this.config.data = data;
		
		return this;
	},
	/**
	 * 渲染
	 * @param {Boolean} override 是否覆盖，默认false，即追加数据
	 */
	render : function(override /* Boolean */) {
		override && this.method.clear();
		this.method.append();
		
		return this;
	},
	
	/**
	 * 选择一个节点
	 * @param {String} value 要选择的节点的value值
	 * @param {Boolean} flag 是否按名称进行匹配，默认false，即按value值
	 */
	select : function(value /* String */, flag /* Boolean */) {
		var obj = this.config.obj;
		
		for (var i = 0, len = obj.length; i < len; ++i) {
			var tmp = flag ? obj.options[i].text : obj.options[i].value;
			if (tmp == value) { obj.options[i].selected = true; }
		}
		return this;
	},
	
	// 禁用select
	disabled : function() {
		this.config.obj.disabled = true;
		return this;
	},
	
	/**
	 * 绑定事件
	 * @param {Object} config 事件列表。config = { onclick : function() {} };
	 */
	bindEvents : function(config /* Object */) {
		var obj = this.config.obj;
		
		for (var p in config) {
			Ly.addEvent(p, config[p], obj);
		}
		
		return this;
	}
};

// 扩展Checkbox
var CheckBox = function(name /* String */) {
	var _this = this;
	
	this.config = {
		els  : Ly.getByName(name)
	};
	
	this.method = {
	}
};

CheckBox.prototype = {
	version : '1.0',
	
	/**
	 * 选择在values中的checkbox
	 * @param {String|Array} values 要选中的字符串，如果为数组，则遍历所有的数值项
	 * @param {Boolean} inverse 是否反选，默认false
	 */
	select : function(values, inverse) {
		var els = this.config.els;
		
		inverse = inverse !== false;
		
		if (typeof values == 'string') {
			values = [values];
		}
		
		for (var i = 0, len = els.length; i < len; ++i) {
			var flag = values.indexOf(els[i]) > -1;
			if (inverse ? flag : !flag) {
				els[i].checked = true;
			}
		}
		
		return this;
	},
	
	/**
	 * 获取选中的值
	 */
	getValues : function() {
		var els = this.config.els,
			data = [];
		
		for (var i = 0, len = els.length; i < len; ++i) {
			if (els[i].checked) {
				data.push(els[i].value);
			}
		}
		
		return data;
	},
	 
	/**
	 * 切换checkbox的状态
	 * @param {Boolean} flag 指定的状态。如果省略则将状态反转
	 */
	toggle : function(flag) {
		for (var i = 0, len = els.length; i < len; ++i) {
			els[i].checked = (typeof flag == 'boolean' ? flag : !els[i].checked);
		}
		return this;
	}
};


// 頁面擴展功能，不屬於Ly庫，放在這里只為引用方便

Ly.queryStateTip = {
	tipHandler : null,
	tipData : '',
	created : false,
	createTip : function() {
		this.tipHandler = Ly.createElement('div', {
			cls : 'queryStateTip'
		});
		document.body && document.body.appendChild(this.tipHandler);
		this.tipHandler.innerHTML = this.tipData;
		this.tipHandler.style.marginLeft = '-' + this.tipHandler.clientWidth / 2 + 'px';
		this.created = true;
		return this;
	},
	init : function(content /* String */) {
		this.tipData = content || '';
		this.tipHandler && (this.tipHandler.innerHTML = this.tipData);
		return this;
	},
	show : function() {
		!this.created && this.createTip();
		this.tipHandler.style.display = 'block';
		return this;
	},
	hide : function() {
		this.created && (this.tipHandler.style.display = 'none');
		return this;
	}
};

// 兼容IE6下滚动条的显示
Ly.scrollBarIE6 = function() {
    if (Ly.isIE6) {
        document.body.scroll = 'yes';
    }
};

// 查看頁面源代碼功能
Ly.viewSource = function() {
	Ly.addEvent('onkeydown',
		function(obj, event) {
			var e=event || window.event;
			var keyCode = e.keyCode ? e.keyCode : e.which ? e.which : e.charCode;
			
			// 按下F9鍵
			if (keyCode == 120) {
				var view = window.open('', '查看源代码');
				var bodyString = "<div style='font-size:12px;'>当前页面URL：" + document.URL + '<br>' +
					'当前页面源码：<br><div style="border: 1px #D0D0D0 solid; margin: 10px;">' + Ly.encodeSpecialChars('<html>' +  '\n' + document.getElementsByTagName('html')[0].innerHTML + '\n' + '</html>').replace(/\n/g, '<br>').replace(/\t/g, '&nbsp;&nbsp;&nbsp;&nbsp;') + '</div></div>';
				view.document.write(bodyString);
				view.document.close();
			}
		}, document);
};
Ly.viewSource();

//if (window == window.top) {
//	window.moveTo(0,0);
//	window.resizeTo(screen.availWidth,screen.availHeight);
//}


function printEvent() {
	window.print() ;
}